{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "from pathlib import Path\n",
    "from seaborn import color_palette\n",
    "import pandas as pd\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torchvision\n",
    "from torchvision import models, transforms, utils\n",
    "import copy\n",
    "from utils import *\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CONVERT IMAGE TO TENSOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ImageDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, template_dir_path, image_name, thresh_csv=None, transform=None):\n",
    "        self.transform = transform\n",
    "        if not self.transform:\n",
    "            self.transform = transforms.Compose([\n",
    "                transforms.ToTensor(),\n",
    "                transforms.Normalize(\n",
    "                    mean=[0.485, 0.456, 0.406],\n",
    "                    std=[0.229, 0.224, 0.225],\n",
    "                )\n",
    "            ])\n",
    "        self.template_path = list(template_dir_path.iterdir())\n",
    "        self.image_name = image_name\n",
    "        \n",
    "        self.image_raw = cv2.imread(self.image_name)\n",
    "        \n",
    "        self.thresh_df = None\n",
    "        if thresh_csv:\n",
    "            self.thresh_df = pd.read_csv(thresh_csv)\n",
    "            \n",
    "        if self.transform:\n",
    "            self.image = self.transform(self.image_raw).unsqueeze(0)\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.template_names)\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        template_path = str(self.template_path[idx])\n",
    "        template = cv2.imread(template_path)\n",
    "        if self.transform:\n",
    "            template = self.transform(template)\n",
    "        thresh = 0.7\n",
    "        if self.thresh_df is not None:\n",
    "            if self.thresh_df.path.isin([template_path]).sum() > 0:\n",
    "                thresh = float(self.thresh_df[self.thresh_df.path==template_path].thresh)\n",
    "        return {'image': self.image, \n",
    "                    'image_raw': self.image_raw, \n",
    "                    'image_name': self.image_name,\n",
    "                    'template': template.unsqueeze(0), \n",
    "                    'template_name': template_path, \n",
    "                    'template_h': template.size()[-2],\n",
    "                   'template_w': template.size()[-1],\n",
    "                   'thresh': thresh}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "template_dir = 'template/'\n",
    "image_path = 'sample/sample1.jpg'\n",
    "dataset = ImageDataset(Path(template_dir), image_path, thresh_csv='thresh_template.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXTRACT FEATURE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Featex():\n",
    "    def __init__(self, model, use_cuda):\n",
    "        self.use_cuda = use_cuda\n",
    "        self.feature1 = None\n",
    "        self.feature2 = None\n",
    "        self.model= copy.deepcopy(model.eval())\n",
    "        self.model = self.model[:17]\n",
    "        for param in self.model.parameters():\n",
    "            param.requires_grad = False\n",
    "        if self.use_cuda:\n",
    "            self.model = self.model.cuda()\n",
    "        self.model[2].register_forward_hook(self.save_feature1)\n",
    "        self.model[16].register_forward_hook(self.save_feature2)\n",
    "        \n",
    "    def save_feature1(self, module, input, output):\n",
    "        self.feature1 = output.detach()\n",
    "    \n",
    "    def save_feature2(self, module, input, output):\n",
    "        self.feature2 = output.detach()\n",
    "        \n",
    "    def __call__(self, input, mode='big'):\n",
    "        if self.use_cuda:\n",
    "            input = input.cuda()\n",
    "        _ = self.model(input)\n",
    "        if mode=='big':\n",
    "            # resize feature1 to the same size of feature2\n",
    "            self.feature1 = F.interpolate(self.feature1, size=(self.feature2.size()[2], self.feature2.size()[3]), mode='bilinear', align_corners=True)\n",
    "        else:        \n",
    "            # resize feature2 to the same size of feature1\n",
    "            self.feature2 = F.interpolate(self.feature2, size=(self.feature1.size()[2], self.feature1.size()[3]), mode='bilinear', align_corners=True)\n",
    "        return torch.cat((self.feature1, self.feature2), dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyNormLayer():\n",
    "    def __call__(self, x1, x2):\n",
    "        bs, _ , H, W = x1.size()\n",
    "        _, _, h, w = x2.size()\n",
    "        x1 = x1.view(bs, -1, H*W)\n",
    "        x2 = x2.view(bs, -1, h*w)\n",
    "        concat = torch.cat((x1, x2), dim=2)\n",
    "        x_mean = torch.mean(concat, dim=2, keepdim=True)\n",
    "        x_std = torch.std(concat, dim=2, keepdim=True)\n",
    "        x1 = (x1 - x_mean) / x_std\n",
    "        x2 = (x2 - x_mean) / x_std\n",
    "        x1 = x1.view(bs, -1, H, W)\n",
    "        x2 = x2.view(bs, -1, h, w)\n",
    "        return [x1, x2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CreateModel():\n",
    "    def __init__(self, alpha, model, use_cuda):\n",
    "        self.alpha = alpha\n",
    "        self.featex = Featex(model, use_cuda)\n",
    "        self.I_feat = None\n",
    "        self.I_feat_name = None\n",
    "    def __call__(self, template, image, image_name):\n",
    "        T_feat = self.featex(template)\n",
    "        if self.I_feat_name is not image_name:\n",
    "            self.I_feat = self.featex(image)\n",
    "            self.I_feat_name = image_name\n",
    "        conf_maps = None\n",
    "        batchsize_T = T_feat.size()[0]\n",
    "        for i in range(batchsize_T):\n",
    "            T_feat_i = T_feat[i].unsqueeze(0)\n",
    "            I_feat_norm, T_feat_i = MyNormLayer()(self.I_feat, T_feat_i)\n",
    "            dist = torch.einsum(\"xcab,xcde->xabde\", I_feat_norm / torch.norm(I_feat_norm, dim=1, keepdim=True), T_feat_i / torch.norm(T_feat_i, dim=1, keepdim=True))\n",
    "            conf_map = QATM(self.alpha)(dist)\n",
    "            if conf_maps is None:\n",
    "                conf_maps = conf_map\n",
    "            else:\n",
    "                conf_maps = torch.cat([conf_maps, conf_map], dim=0)\n",
    "        return conf_maps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class QATM():\n",
    "    def __init__(self, alpha):\n",
    "        self.alpha = alpha\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        batch_size, ref_row, ref_col, qry_row, qry_col = x.size()\n",
    "        x = x.view(batch_size, ref_row*ref_col, qry_row*qry_col)\n",
    "        xm_ref = x - torch.max(x, dim=1, keepdim=True)[0]\n",
    "        xm_qry = x - torch.max(x, dim=2, keepdim=True)[0]\n",
    "        confidence = torch.sqrt(F.softmax(self.alpha*xm_ref, dim=1) * F.softmax(self.alpha * xm_qry, dim=2))\n",
    "        conf_values, ind3 = torch.topk(confidence, 1)\n",
    "        ind1, ind2 = torch.meshgrid(torch.arange(batch_size), torch.arange(ref_row*ref_col))\n",
    "        ind1 = ind1.flatten()\n",
    "        ind2 = ind2.flatten()\n",
    "        ind3 = ind3.flatten()\n",
    "        if x.is_cuda:\n",
    "            ind1 = ind1.cuda()\n",
    "            ind2 = ind2.cuda()\n",
    "        \n",
    "        values = confidence[ind1, ind2, ind3]\n",
    "        values = torch.reshape(values, [batch_size, ref_row, ref_col, 1])\n",
    "        return values\n",
    "    def compute_output_shape( self, input_shape ):\n",
    "        bs, H, W, _, _ = input_shape\n",
    "        return (bs, H, W, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NMS AND PLOT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SINGLE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nms(score, w_ini, h_ini, thresh=0.7):\n",
    "    dots = np.array(np.where(score > thresh*score.max()))\n",
    "    \n",
    "    x1 = dots[1] - w_ini//2\n",
    "    x2 = x1 + w_ini\n",
    "    y1 = dots[0] - h_ini//2\n",
    "    y2 = y1 + h_ini\n",
    "\n",
    "    areas = (x2 - x1 + 1) * (y2 - y1 + 1)\n",
    "    scores = score[dots[0], dots[1]]\n",
    "    order = scores.argsort()[::-1]\n",
    "\n",
    "    keep = []\n",
    "    while order.size > 0:\n",
    "        i = order[0]\n",
    "        keep.append(i)\n",
    "        xx1 = np.maximum(x1[i], x1[order[1:]])\n",
    "        yy1 = np.maximum(y1[i], y1[order[1:]])\n",
    "        xx2 = np.minimum(x2[i], x2[order[1:]])\n",
    "        yy2 = np.minimum(y2[i], y2[order[1:]])\n",
    "\n",
    "        w = np.maximum(0.0, xx2 - xx1 + 1)\n",
    "        h = np.maximum(0.0, yy2 - yy1 + 1)\n",
    "        inter = w * h\n",
    "        ovr = inter / (areas[i] + areas[order[1:]] - inter)\n",
    "\n",
    "        inds = np.where(ovr <= 0.5)[0]\n",
    "        order = order[inds + 1]\n",
    "    boxes = np.array([[x1[keep], y1[keep]], [x2[keep], y2[keep]]]).transpose(2, 0, 1)\n",
    "    return boxes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_result(image_raw, boxes, show=False, save_name=None, color=(255, 0, 0)):\n",
    "    # plot result\n",
    "    d_img = image_raw.copy()\n",
    "    for box in boxes:\n",
    "        d_img = cv2.rectangle(d_img, tuple(box[0]), tuple(box[1]), color, 3)\n",
    "    if show:\n",
    "        plt.imshow(d_img)\n",
    "    if save_name:\n",
    "        cv2.imwrite(save_name, d_img[:,:,::-1])\n",
    "    return d_img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MULTI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nms_multi(scores, w_array, h_array, thresh_list):\n",
    "    indices = np.arange(scores.shape[0])\n",
    "    maxes = np.max(scores.reshape(scores.shape[0], -1), axis=1)\n",
    "    # omit not-matching templates\n",
    "    scores_omit = scores[maxes > 0.1 * maxes.max()]\n",
    "    indices_omit = indices[maxes > 0.1 * maxes.max()]\n",
    "    # extract candidate pixels from scores\n",
    "    dots = None\n",
    "    dos_indices = None\n",
    "    for index, score in zip(indices_omit, scores_omit):\n",
    "        dot = np.array(np.where(score > thresh_list[index]*score.max()))\n",
    "        if dots is None:\n",
    "            dots = dot\n",
    "            dots_indices = np.ones(dot.shape[-1]) * index\n",
    "        else:\n",
    "            dots = np.concatenate([dots, dot], axis=1)\n",
    "            dots_indices = np.concatenate([dots_indices, np.ones(dot.shape[-1]) * index], axis=0)\n",
    "    dots_indices = dots_indices.astype(np.int)\n",
    "    x1 = dots[1] - w_array[dots_indices]//2\n",
    "    x2 = x1 + w_array[dots_indices]\n",
    "    y1 = dots[0] - h_array[dots_indices]//2\n",
    "    y2 = y1 + h_array[dots_indices]\n",
    "\n",
    "    areas = (x2 - x1 + 1) * (y2 - y1 + 1)\n",
    "    scores = scores[dots_indices, dots[0], dots[1]]\n",
    "    order = scores.argsort()[::-1]\n",
    "    dots_indices = dots_indices[order]\n",
    "    \n",
    "    keep = []\n",
    "    keep_index = []\n",
    "    while order.size > 0:\n",
    "        i = order[0]\n",
    "        index = dots_indices[0]\n",
    "        keep.append(i)\n",
    "        keep_index.append(index)\n",
    "        xx1 = np.maximum(x1[i], x1[order[1:]])\n",
    "        yy1 = np.maximum(y1[i], y1[order[1:]])\n",
    "        xx2 = np.minimum(x2[i], x2[order[1:]])\n",
    "        yy2 = np.minimum(y2[i], y2[order[1:]])\n",
    "\n",
    "        w = np.maximum(0.0, xx2 - xx1 + 1)\n",
    "        h = np.maximum(0.0, yy2 - yy1 + 1)\n",
    "        inter = w * h\n",
    "        ovr = inter / (areas[i] + areas[order[1:]] - inter)\n",
    "\n",
    "        inds = np.where(ovr <= 0.05)[0]\n",
    "        order = order[inds + 1]\n",
    "        dots_indices = dots_indices[inds + 1]\n",
    "        \n",
    "    boxes = np.array([[x1[keep], y1[keep]], [x2[keep], y2[keep]]]).transpose(2,0,1)\n",
    "    return boxes, np.array(keep_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_result_multi(image_raw, boxes, indices, show=False, save_name=None, color_list=None):\n",
    "    d_img = image_raw.copy()\n",
    "    if color_list is None:\n",
    "        color_list = color_palette(\"hls\", indices.max()+1)\n",
    "        color_list = list(map(lambda x: (int(x[0]*255), int(x[1]*255), int(x[2]*255)), color_list))\n",
    "    for i in range(len(indices)):\n",
    "        d_img = plot_result(d_img, boxes[i][None, :,:].copy(), color=color_list[indices[i]])\n",
    "    if show:\n",
    "        plt.imshow(d_img)\n",
    "    if save_name:\n",
    "        cv2.imwrite(save_name, d_img[:,:,::-1])\n",
    "    return d_img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RUNNING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_one_sample(model, template, image, image_name):\n",
    "    val = model(template, image, image_name)\n",
    "    if val.is_cuda:\n",
    "        val = val.cpu()\n",
    "    val = val.numpy()\n",
    "    val = np.log(val)\n",
    "    \n",
    "    batch_size = val.shape[0]\n",
    "    scores = []\n",
    "    for i in range(batch_size):\n",
    "        # compute geometry average on score map\n",
    "        gray = val[i,:,:,0]\n",
    "        gray = cv2.resize( gray, (image.size()[-1], image.size()[-2]) )\n",
    "        h = template.size()[-2]\n",
    "        w = template.size()[-1]\n",
    "        score = compute_score( gray, w, h) \n",
    "        score[score>-1e-7] = score.min()\n",
    "        score = np.exp(score / (h*w)) # reverse number range back after computing geometry average\n",
    "        scores.append(score)\n",
    "    return np.array(scores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_multi_sample(model, dataset):\n",
    "    scores = None\n",
    "    w_array = []\n",
    "    h_array = []\n",
    "    thresh_list = []\n",
    "    for data in dataset:\n",
    "        score = run_one_sample(model, data['template'], data['image'], data['image_name'])\n",
    "        if scores is None:\n",
    "            scores = score\n",
    "        else:\n",
    "            scores = np.concatenate([scores, score], axis=0)\n",
    "        w_array.append(data['template_w'])\n",
    "        h_array.append(data['template_h'])\n",
    "        thresh_list.append(data['thresh'])\n",
    "    return np.array(scores), np.array(w_array), np.array(h_array), thresh_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = CreateModel(model=models.vgg19(pretrained=True).features, alpha=25, use_cuda=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores, w_array, h_array, thresh_list = run_multi_sample(model, dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "boxes, indices = nms_multi(scores, w_array, h_array, thresh_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ca9216fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "d_img = plot_result_multi(dataset.image_raw, boxes, indices, show=True, save_name='result_sample.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f1ca409bcc0>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAADnCAYAAAAQL525AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJztvX3MNclVJ/Y73c/zvB8zY49n/aGJbWIbzZK1CRnMxGuJ4Djr/TDWKgMr2NiKwAErgxMsLRKRMBAthAiJ7C6LhJKYDMKxSYix41mDhZwss17AWSkGxmDMeG3jsTF4PJMZM/6a8cy8z3O7T/6oqu7q6lMf/XW7733rJ93nube7uvp0ddWvTp06dYqYGRkZGRkZx4tibQEyMjIyMpZFJvqMjIyMI0cm+oyMjIwjRyb6jIyMjCNHJvqMjIyMI0cm+oyMjIwjx2JET0SvJaJPEdEDRPTWpe6TkZGRkREGLeFHT0QlgD8D8HcAPAjgDwG8gZn/7ew3y8jIyMgIYimN/hUAHmDmzzLzOYBfB3DnQvfKyMjIyAhgKaJ/PoDPW78f1McyMjIyMvaMk4XyJeFYx0ZERHcBuAsASpTfdhXPWEiUjIyMjOPE4/jyXzHzc2LpliL6BwG80Pr9AgAP2QmY+W4AdwPAM+gW/pv0moVEycjIyDhO/Ct+71+kpFvKdPOHAG4johcT0RmA1wN4/0L3ysjIyMgIYBGNnpl3RPQWAP8SQAng7cz88SXulZGRkZERxlKmGzDzBwB8YKn8MzIyMjLSkFfGZmRkZBw5MtFnZGRkHDky0WdkZGQcOTLRZ2RkZBw5MtFnZGRkHDky0WdkZGQcOTLRZ2RkZBw5MtFnZGRkHDky0WdkZGQcORZbGbtv0OkZwDUAgOv5NlOhguQ8uQbI30+a66ZizmcRMl8u7yEIlKOIoXJPeE+p5e+tJ/0Mk/Lz3GT8tXNj7bozoix671rKI9Zux7ZHt7yoAF+cj8trBI6G6MH1IqQo5mlemv3ynEqzKEFPwdoNVMLSMgU65bneU1I+U58zUN8WxT7qTGinOxLIN1Umq5zMO2oIXyDfHpGbtJKiNwV7bodHQ/SdhjZXIbqNKZSvObclrQvYJrGvgcgIbC/37x2LdA4SwYXyG4pYeaxN8FKaUJmI1/Y7R5srOlq+1IZnJPheR7NHHA3RA5i/YvryC1W8fWhdcz7nAnsGD8LQhmuQInfo3XTSBd7T7HVqQHm7aceWlTf/kc+2Zp0Zem8SiBwQSV8dpqRyiY3gqCBvmjVG+6OZiIheSES/Q0SfIKKPE9E/0sd/moi+QEQf1Z/XzSduAGtprqGKx/UynzlkNp+1YcuSKs+QdEkao69D39hoaO13tvb9x8Anr6ctpZDwXGn2iSka/Q7AjzLzHxHRTQA+QkT36nO/wMz/bLp4e4BUEQYPD3l+bet6hXkfvvI8NKKxMZfssTJaAode7gPKimueZF6xr90K4Y8memZ+GMDD+vvjRPQJXA8bgB9yhQcOW/59y07F9rR6G2PKY0zncMh1JoYZ526kzsFnwlHHZ7ltEmZ5QiJ6EYBvBfD7+tBbiOhjRPR2InrWHPdYDG7FjzUE6fwhafOHJKuLMbJH32cRbuix84eGYybtEGZ8bh+hh9Lb59eYjJ1cg4noRgD3APgRZv4agLcB+EYAt0Np/D/vue4uIrqPiO67wLWpYkxrjETtZ8y1Pnn29bmekNIR+97nlLKb430s1cm6zxz7ZEzGGOJ2CX+fmOR1Q0SnUCT/a8z8LwCAmR+xzv8ygN+SrmXmuwHcDQDPoFsOS80INZY1iFe6Z2hc2PFE2FjRpxDRqA55j+/F3Gvpsfm+SJtoe/VkTow036xF2mMwmuiJiAD8CoBPMPM/t47fqu33APDdAO6fJuKK8L38iAvlGhWgZwdMkR0QXBBH+HaPJYG5iWrKSuXU8kpA8y6kdRjmmfdlX58LU+ReAlvufOz3vpE5nika/bcD+D4Af0pEH9XHfgLAG4jodgAM4HMAfmiShEMw1+RZau++EZKX7uud7Y+VUUjb95qpBjS6oWQ1URPvlMuYvFKuccrT63Vhl31qh7k0uQ/t4NYmWLs8lqx3Y7FRU+oUr5t/A0AqvQ+MF2chzEQWXk0NCQQ/RYYRnVcw9kqqaWFI4wg1uj2aWrzvweQ3Z0ccqA+mbMW6EyLRuTG23i3hcRRc6TtiAZx9bGgIhSUglbWvHPfcIRzXylhg9gJ0J118rlJLyjBl5WZohd7sjXkl08LQYFUUk7Nwrq/lMmLfa6m5N3zvEP7s5b5nLXLuTt2+bmy+PpmS5nxmKL+Y59bKJpzjI/oZkeIXuzjJx5BgD5xFu98nPGU4atQkEbxL5G0C+XhZdn9rQmlSOx1BpwOwSV8TPrsdQXPh8EBdiyI2+pgSg8Z7zwn5ziTDIubXjtlu/+adoyH6oOY6Iq9R6da2z0VIe6/a/RjMQfBS52wTvI8MLPKPafxsiMgQvOkI7A5An2tI39Lkve9h7fozFEu6iwL7mQtIKfOYMjRhTm9fOBqiB2Qim9w7CxqzmOfYl5gi39AOLFAxZyP7PZgfkt6dQ/IiSRsSJ+pp820nkD5pS8KEao/89X2oR/hFx5QDbGeZvIg1FYDQGhVg/3JtcfSbiOMheuo3oM65ue4B+IdgS3nc+PKNEYTHrBMkmVBldp93jBtZ4rtIHi3pdF6t3RAukUorTcqSPu7mFYi3w8yq/E3nb34D6lit05QlUNf6fA2UBGbqvDsqHNPPnog/1JF6vYXWhFT/xsg1xA3XN8F6YDgeogfkFz/lpUgNQbKvrrVwwrcpggRPo9ibGWFKfmNI3iZ4k9aYWBoit8i9KLqav6TpA01ZEzNQVQAXLekX0FERCUAFgiJ0LgpF8ib/qlL5ul47Pk+dCfC53W5isc8QDdlXB7bSCRkMaZN7xHERPRAlhR58O8r4UHS1sdVI3oYrkw9DyX4IghN3M3caUpkbEpUI3hB6UXauJ0PohuQLakleX8/OvajR2rmZOGy0deautl4zUNSK8InAVaXSE6nOwSUFpwznnHey8xx54XKmun2R9dB6ODS9XbapbXJPOB6i9xVsCnEHQJIddiFybwhgDLZI9nP4wkdGT2Tb3Yn6BN98p9aGb66h9jiKAlwWXaIvWsI3aE02irANwaNWWjvVNUAMBgDS2r0mfHCr2VNdd+uTp+yXIPvVMcTfPDW/6JqQhc0tovIRaJN7VhCPh+iBoLbt86QIEat7TYiI3bRDCNu+VuxYDglLNiiJ5NsfllbftbmDlNmmMc84BA8i8EkJWETPZUv4rO9D1gYpVLE6XtegqgYKBmpqCR8AVwBQK5NOXYBIm3GqahDZz4nVTTdr2LcP0KY+N46L6IGwe52A6OIZIb1LwEPzSMFgkp/Jnnso2qPXJ94meWuSlTTZ9wi+1OR/UipyLwpF4CWBC33e3FNr81QzuFIaPdU1uKg14ZPS4o1pCLBMORWAElRVKn/mPtkDs5sxQtvZbcJOn4JUF8i1VqAeQDkeDdH7tO3oIhnPqscpGErSkzX3AyHnFKTEpul1rFqbJ4qQvNHYi0LZ3otCHSsK1GcnXXIvzHfSjK1vxQxUSqMvAKXFF0VL4DW1Gj6giBzahFNA/TcmHON3b9vsvZtUHM87XgwzmQ5nxUZs9UdD9EBAs/aRvHsugfQlUt6biWVKhYloiZsnEt8ErE3yBWky1wRvm2rKAnx60iF3PimUKeWkQHX5BHxCqEvSxwEuCfWJJnoAYDUZW+wYVAEnZwXoogbtalBVqv+7GlzXoGsXqj5Vxm5P4Ep71bieOHXdVVT2NDkZXOG9BGLEO8dz75vcx5TbCiOA4yF603Ck4wahyIxzI0ScQ1/0ggSvkmyD5FPIJjhCIz/JN541J6UiWUPoZQE+LVGfFahPC3AJ1Kea8EtCfaKUcGJooicUO032uwIFEQrTyRgxdgCXRTfiX61NOqwnhWv0yH5NHJQpZys4oPKaTPRE9DkAj0MZIXfMfAcR3QLg3QBeBBWq+B8y85en3ms0fFHvxppYQu6VKaTp8w6ag3AHakQHQfLuOdvfHWi1eZ228cSxSJ5Li+RPCnBJ4NMSXCqCry4ViuBP1IdLoD4hVKdoTDfEAFVAsQPKC0Jxwa2JRltmGpnqEqwvhV44Rcxg0xmh6pcBERj71eptBOvClnzVt4AhJL8B881c45z/hJlvZ+Y79O+3AvggM98G4IP69/LoTczN83hsVkJKqLn7GYupFYHrQY2Ra94EyXu3V5NCIoTCGwBd90mX5IvWTMMnRUvyZ+pTXSpQnRGqS+qzu0zYXQGqK4TdFcLuqv5/BercJVKdwwmhPlN51ibvk3YE0cwFmHmCgppPp0OyPYYy1ofk1mt/xmKl97uU6eZOAK/W398J4HcB/NhC95oHwtB5su19HxNDU3ZAmoAxE4SzmgY6YQ70xGtD8KXjD6/t8hYRG01efQjVGaE+BapT9b/W/6tLaDX6Gih2BD4BUDCqcwJQqBMo1FwrQ62GLQnEhfaxZ3V/s1hKFQYkrT7jSLFyBz4H0TOA3yYiBvC/6L1gn2e2E2Tmh4nouTPcJw3ucvORCGrw0YsF8l0xROlSGEL2o0neZ7bR3/srYAWTTVmAy7JP8mea5C8VSpM/Q0P49RlQnwDVFW5s9FQT6AIoL9SK2bLZ016bWWpF/AUAvqiBGqBSjQbJrKRtOh8AbNnqtW89Kov8t7a8P2M2NB3+njAH0X87Mz+kyfxeIvpkykVEdBeAuwDgMq5Ol8K2uc9kshmFWMOck/BXIoGhpD2HJt9bHNW9Qesf7650PSm1Rk9+kj8j7C4D1SVCfQZUZ5rozxi7K9xq9No+z9cIXADl00DrkmPeZw1i5YePWrtSUu347xdqNZWt1Xfq7/o23Q6u987mCMxpk4memR/S/x8lovcBeAWAR8wm4UR0K4BHhevuBnA3ADyDbtlQrQ4g1viGNIiRO89vDTGtfhTJe+MVCdq8sZmS/n1S6lWupf7eavHV5ZOW4M+UFr+7RKguA9eepf5XlxnVZUZ9uQZdrnD5xmsoCgYzsNuV2J2XuHjqBMXXSzAVOP06cPIUUD5NODkllNcIfK0A7Vh541DVuOE3JbHbdfzqqW7c9P3rQbIv/eIYq5AMXRW/xALLGCYRPRHdAKBg5sf1978L4GcAvB/AGwH8nP7/m1MFHYQZTDeDMUbrOUCyT9l1K5Q24Qbtdzv4mI2Oy6yjzVsTsVwSuLBcKLVHTXWmJ17PCNUlWBOvjOpqDb5coby6w5Ur53juTU/gtKjATHhqd4qvn5/iibPLOC/PsHviVGnvTDq4mTbvVFA++XWBolYmHaoL5V9fq0lYdrV618XSaPXZfLMuBsTCco9tKYTJVI3+eQDepx/sBMD/wcz/NxH9IYD3ENGbAPwlgO+deJ843I0fYmRvvwR3K7ihL+jAGuI+tMNZNflOGsGlsvltebCY/80ELGmTDbUTrWfKXFNdViS/u7ECrlQ4u3qBZ9zwNG658iRue8YXcam4QIUCX99dwmPXruLR05vwWHEDLr5yooi7Bkhr5uZTnxQoKlb+9JV2wywcMw5rXb8goOLOs2yGJA6sbs+C1D0TIpr5lt7jJKJn5s8C+A+E448BeM2UvGeBIftQYaeSvI8Y12oIE+87t9fMrDt5DYEdpZJIuzOqxU7NpyDUpSb7E7UIytbo6zOguloDVypcvvEcz7zhKTz3hifwgqtfwbfe+Be4XFygYsLj9RU8fOlmXD25AAB84YYroIpUjJta2fCNRl+fKoLnisGlrdUXINunvmCg0qRg6urKi6cWQ2wEe0CdSqr5xdXuoyFZFsLxrIwF5AYywIwziOTnqpRDzTczNobVtrMbQ+qxd2gakONWyQXpGDZqAVRdtmSv3CiB6ozBl2qcXt7hxivX8OyrX8c3XP0yXnLli/j3L38eN9AOFQhfqS/j5vJJlFTjvC7x0NWbUV2QWiG7I1QXatVsvQO4hNXZaK3eaPN29Ew2HZXgapnNN0eDNezyNo6L6H2QyD5Fk9+XFr8BW71vJyLf+ZE3SU8bGj00pF64J7offcwEJ+MC3U+p/58AdFrj9GyHG87OcfPZU3jO2eP4d06/jBednOMqlajAuKl6AgDweHUZX7x0E04v7XB+VmpffN1xnKDpTOiElN99WYBJx6E3G5wURVertydlpaiWWGFCNncuItYm7TE4HqI3mzD7Qgh7hsOT/OX3jT02vHkXN43vxLxulQnysZTEmMap/Q0CUDCKgnFaVrhU7HC1vIabyqdwI53ianGGimvUxdP4an0NN5VP44byGk5OKpyXDC7Z0eBZdS76QwTlblmhO2nckUtr9W5ojq25Wk7FBpSa6xFHQ/RiHBoojS2K1Ia0toazlV3opYY65169Lhy3Si+sjUHAOm68jh9PFSvLSQUUFcA75RNPFUAXAF8rce3sBI9fu4Qvn17Bo+fPwDPLp/Dg6WO4Wp+jBvCV+gRfqJ6JRy6eiS+d34CLixKozCQsqcBnzfNDdyrUH2nYK3iZO66WjQXH1eq1+WZsB5xdM+NoArtFOiM2u4uNxQrrfI6G6AHIhF1zWPs7xEBOW7TZzkXsCbuCiTCEaIhee7pQUYMrApVAsVOad11BTaLugOICKC4IdF5gd+0ETzx9CX9V3ojL5Q6Xih0+ffolXKYLVFzg8foKHrp4Fr5w7WZ88dqN2J2fgM4Ldf0O6qM7FOholzF0XC2B1s1yZq0+++Ff3zguovdhaAXfGolK2CLZj8VcZiKjxVe1soUbH/aKUVQ1qCpAFanVrQVQlgw+V7FriqcIVXmCpwrGl3R2Oy5wubjApeICNRd4sj7DF89vwkNPPhP/3xM3gZ88Qfl0gfIa6Q5Df0wYYz2aaDofLeNayGR//eJ4iN5U4LHbiY0M77tqDO81yH6K5j6lrCTtnmsAJcA1mNW2fg2p1jVQUaPVY6c8Yrjg1qxSEIqSUZaE8ikCUKDiUzxZFdjtCjy9O0HNhLOiQg3C07tTPH5xCV9+8gqe+PpllE8UOHmSUD6twiGU56yJXmv25lNbowygs+aDmYPvcI0NSVaD9Hx7tOfvrS2vsKDzeIge8DeCkM1tYvTHTRD+1jGibJLNNjXruDI6YLzeu5VJhwGuoOzfBemwBCrSpAlHwwUBxDh5krQPPKE6L3DtvMBj105w7eIEZaHqyK4ucH5+gvOnT8FPnuDyEwXKp0wIBEZ5TZF9ea63Gqys+YFKBzar6q6Gbz9HCDNNyq6u1U8k7tVcgh2k2un3sb90Co6L6EOYSRPa3NB3iJY3tbMb2kjn6Py8e/1acy/MrRdNrf3Va1ITpUSN/3pxoUgeMP+hryOcPKmSFRfKDFNfO0H1dIGvnZcwm4ugImBXgK4VOH2KcPJ1i+TPW5Ivzhnlea22GaxqbUKqW9u7bc4ZWp9Std7QKCGV7OceQUzZ5Bt9ZWovnVZsji+ArayKBY6J6K3KsdRemKFKtepWbHYDGhMDfyBRNPDtrrVGORjzjfG4qWrl8bKzPClPSxSAik+jBNXXKl/6YqeiVxYXKkRC+XSB3bWiIXq1ChYozpW55vQJbkw25TmjvGAU+kMXNQq9h6z5oNLEr01LjdnG9hhLWRVrk6HvHUc8tBYj+zlMLdKmM546ZY6voYBJWn2M3Jtr9rz6+XiIHvLLji38WU1DT2kQqYRpP8NcNs1QPj65ZiL4QWabogbqQnF2ZfzQlRZOrOLLqGBiJUqgiWRZnKuFTuXTKgZOeV40K2bNXrH1iYqF024PCKCGJnTg7IlaEfs5o7iolalmpzqZ4tquJfhdBVSVIvldBex2aqNwtjT8qmpJIkUTHNOJO4QdU0yatjGznXxoG0zaS3gG7b6jrNnmXt/WnxintU92zxyBoyL6FOyd2Pdh7kjdtzYl7xRb8QBIFVoMwzug4vcaCrdkz8xqUtbOG8rTkYwZqIbe7JuVJ06tEnFp9otlvTk4UF1DOyTQViHjVXPyZK2+X9QNwVPNiuAvKhX2YFfpeYPWfNPR5GvPZOwSGl+A9OXkadry1JHsmlr5aKSadNxnOrKtBPeOTiXZxxZ+KZhpyX8ny5Sh4px7WoY2Qg/IFUJy2oBnQjsEdhpczWDUoG5iFW5Ahx3AiTLvFMzgE+0VA+VyWZwUOkSCcrssT6hZYUua6KlS5pmTp6qW4HeK5FGpjsaYalDXIE32aMieuyRfs1ebX8zOG6ubVhval0lSIvxVnRxiq3glso91VvqafdvvRxM9EX0TgHdbh14C4B8DuBnAfwngi/r4TzDzB0ZLOBSuprJH0l/CTp8SCrW5/xKVx2cb3VK8D9uEQ+o/o1akDqBh6qpqSF/FlzH2fG6TlXUbvqBUQdC6Gn3rUVM8rcwx6qPt6zXUiMLV5KtamWfqWq3YkjT5LUWtTNH+52pPqSalgSOSveBARiGjiZ6ZPwXgdgAgohLAFwC8D8APAPgFZv5ns0g4SKjIyx9TOdzKPLefr7SRR4hEA8HZYtr+UPOIBG8eqX7BM5KZaMJhAqDJvgDI2O0BtUpWXdja8Cul4Rd6T1cuSYct0H72J+1zEbMmcqWNF+c7rbnrvIy2bhO8canUnQxqx1xja/NTMLfmO2TeZ6pJMCW0Ry+A3Z7WFNha/VxxeiZ48ozFXKab1wD4DDP/xaY0vTmQ0nlIL3/EZOsoEh1A/EMQvXbsgo/GTh4p184uUn5ZeiacmrUzjdHsGVQWimjLop2gNdp8aQi6AMjs/qRjz1jx7ZXM3Nj2USmib4jcjrHjmmg0ybcTsALJ2+WxBc1+oAnPV1+a50sJQ+Ij/LWDoNnyDN3zeSNm5LmI/vUA3mX9fgsRfT+A+wD8KDN/2b1g9s3BtzKUS0FqQ5HIVFwhajfCBCJNIWnf9b5rYx2Dq7W6W+elQlhV2CV7ywuHlTbPOmokVTVMdEiq1apZ1vk1Zh6b7AFQSc01zXPUWru/2LXE7oY5sNwoOyRfBUh+rGY/Yru7FHRGGilKif1e9DOF7t3pBJbwHFsSPsIP8VDMk2dB0NRhIxGdAXgIwMuY+REieh6Av4JydPjvAdzKzD8YyuMZdAv/TZq4IVVnCD/hmcZqwfoFNvZFtwKk2LpdEk0lf4kwQ2WQ+oxSHiF5fbDlG/NuUuTVsnTLk9r3UBZAWeoFVIRmu8Fmxx/q3seJZw+gmbRtA6c5BG8FI2N7MZTjYcMN2QvlEtsnYaRmPXoEJtWt0GjL14FL791K13nOFE8VT8iTOTx3Fp8A1nWSL84nZ/Wv+L0fYeY7Yunm0Oi/E8AfMfMjAGD+AwAR/TKA35rhHumYau/UttpBkOyHNoaSvNR4QhA0qeAzxPKL5eFcHx+2F908l5g0NvsR2IRvNHxAhUIgZbdvJmTtbd1q9J9X7wJF9uZPNtkbuzusZ3UJyCV8aVHUkPIY6vmUujOXC/vdha4R6gJL5kRJEbNGn52YPvuyX3vMrosvflwhJv8cRP8GWGYbIrqVmR/WP78bwP0z3ONwMWTIGyH42BCctf05huhwOpKH/AytHdtN1+Q5huyHdrraFNPs0Wk4tdDeLnrrPjabcgOt2WbIvZlbrZ09IxaX9ANulFORRPJDyjJxjqZ334LaMtdgi9B7eVt1w91fNXx/3ZGPmZR1be6HYCqaiElET0RXAfwdAD9kHf4nRHQ7lOnmc86544NVScg2FQydaI1oSfK1JBJrFCGtMKXNSNebBieZE+qRZD/GxOQsL280/BoAccd2bzb5YGkS0G78jp9+k9bV4jsy1b1r2LLZdzD35GviRHbyyE64pmcia+5XtKMoQE1gGwL3jTydumETfuqCu4wwJhE9Mz8J4K85x75vkkRrw9cwImTQGeqlbJ7ha2TWcUlb6qf35B9y4QqGNxAatxTDRjJP1UK+3DbeHtn35BoxXHYbvYf01WKpujHhANYzmU0/OoRtdVqSuKIfvExAnUlXQ/YJGEVoQzy0LIiuuZ70TVppPsqtB0U7mumaZywt3yZ7c0yQyb5/p2w2HL7ZG912z/IezcrYyQiRjF2RQwGXqPCTfIq3io/kxywgGTgp3MAla1tL92m5SmDAfUQztC7qbkM3ZD/VFTdGhJYnTed+dmdWOdd0VlgH5LO19BhGeNUMIXmvMmHPQaRek3LerQ9uXeiMgEyauqPdA+jXBWlOx5Xf6gS4QK9zXTKiZSxuVijtqkEPkYk+TjYR+5308gYTvJUuqsXHohW6kAg5BDsbQ9RSfr2JywI91ddcajbFXjykrMfUYBZDuXZ7CyKxVhF5U00ujkfNYqYHyWQTGiECaf7tblqX4EMTurYt3dLujTxBspcw1i3Xh0T7vC9g4pAAbWuS/fVJ9KmapM8040tX6PjnvslVGyE7fIzcUytLx13Qo325sG3QZWQk0cur7OZDaCe79MhAtNfbSLUbdyY9PW56gIoaacrBeMj4XHEXXqgkbmA/V8P3kPygeuWihGyqdAneGckC6L7/UhO4rd2bLO36AMTfgVt3hEnZqFY/4+Tr0NHDWmR/fRH9IK+D4SSv/scnV7siTSD4lOcRzC1Bd0i74TQnhMUhgbx6+RS6kbv2+s6zjWx8IZJ3jpNZbCWQ+94m+FximBjDv1f+PnNNaH4leIPIiNQi+a6XlZnf0O/dmPYET5me7T5E9pY9n0wk0AWwJCGvQfbHR/SSN8dIglc/00m+aXQB22gr0kATzZwk715riLAZSjtmFo8snWewtObWywJhc41p1DPsnxlccANYxBNYkDSnaSkUQkBy6ZtI+MmyhOZZXHhNN36St7+3dUmYLLW9tHr3GWieWdgseFDhkz04PqIHWrKfuPCJpAbiWfocIvl43JiItjUTyfvTCp2j4BdvHxdJ3v5uL35hrc1JtvoxJB/S4nyNsmbV8YSumcMTIrbEvVlI5VlCvySG1IlYGnLqt6A89Dc2r7yk3BvlxbyzxFXb83rfLEnw++48jpPogUlafPB8SNM2pOWbWPVd55NB9FcfaGftXBpquNRvnD4ZBtxvUTe4kNlF0iBDjcuzFaWE4CgvFMRKenZXux8Q2TBmtlHzRZ4JVDu9D76RsTsnZeB6x5j61JhsPARtPU+P7G2D2X3BAAAgAElEQVQIxC+aATN6OF6iT4WHKL0xa2zY2m2I5BM1o2DasQTvy0+a/EpZxDQTFmmgIc3ctwJSpx2iYSV3BKmd2tKrM2Mk740amaiouA4I9oSp9I4Dq1qD9cJdcHcIOLLolYeJISTvIUzJhNFbUJJy32BnECD5MQumIpiFhPfYaXSQGj0wli6GQKMNTbbNtXvSJD94VzNvBer+9oULdud7TIA4N38T2gB6vqaC30zoC53houNxI3jfbAG++rNiuIXjIfqYWWCEPzyADlmKS7NtTca4sxU03B5q8vAL6JUrJrdBR+6JroSdvHzzIUSqkRsf+wJqYk4vnukm9RDjyM5C0rqpoF4d4bH2+UhdSxkheDej9mXrqx820doulaYe2pOoqW62ADrusq4cdv0vnHsAaIK5GZNgrTd9qRmA5XKJUh1zXTkBkNnay118ZI9GXe+bNVbJDrnfSmR/PEQP+F/yGJL3Tbba3x2SV8dGknwMQ225nklUZlbNJ0EjHEyyUiwTc293BWrRD341mxyJCJLxFM+tmRGe6yk8351RpUDyozemcU01hSZ+V6snVuVYaUJmPSFuu1y6czgu3PhJbiiF5nb2XEABKuqj8JaZC8dF9BKmkHyoQQj+8v5AT871PuKyNWM3ZgvQt/cNqciu+14CefaWq3vOdRq+ga11sfHLt7T6KVrXSLOQrUEPInn7WAo5TtHahBGkP22f5LvvxaqjkivkWKK3Y/nbJE9C7H5A7QWgN31pzDhNqA1dJyRI6zm0iaYJh2zcc6WJ2tjCqTmw0Rg7LpJqIxG9nYgeJaL7rWO3ENG9RPRp/f9Z+jgR0S8S0QNE9DEievlSwsvCFt1PMGlck++gGaZ6SE263mPS6GlABsx9ojHH7HNmS7ohHwBj9yglos5HfD6i/rO5qzNHwOvZ4XHNjC1DH0zy7vklRhiBEWQHUh2U5oYMsVsk37w727Y+5uOSfFGAS/Ux593fsL73vIGkemOeo3DSmuM+OOeooOUWJx0IyQOJRA/gHQBe6xx7K4APMvNtAD6ofwNqI5Lb9OcuAG+bLub8SCX5npmme7KbThouj0XN8gfoE3/sY2C7EHIC4bsNUPq4jd+bjtpGbRNR6NMRZUHTyUoNdhABSQqGRYwpJO99Z6nv0KR1Sb4gOT/fOZvsXVOn/VzSCDlA9qE6kkr4i3YMKyKJ6Jn5QwC+5By+E8A79fd3Avgu6/ivssKHAdxMRLfOIexcSCJ5yT++kz7QAdjnffkDXRKWCF1Cajr3PvZIwLpOJHvfaMNA0u7shts0YIGIhuBIGpxEHuJiPMlUKBG8StRNY653487YJG+/M1czd0ww4qfUeZceIi+L9uN2BOa8S/Z2GUij8c7osEv2ZD/HDKurjxlTbPTPMztJMfPDRPRcffz5AD5vpXtQH3sYG8AQc000/KuULjX/kDY9RMOUYsC7sO3yMcL1mUl86TqapJO3ubwo1LZ7BWn7vP097N9uu811V1pSU4Z7XTST0mF54iQZm3FIYwyOIKX7+5wAtDbfIfnmuEOcTV6JdUPn0SN5sjZVZwaonYjl5pj1fLbrpYEbeqNZQazf9wQ3ylRPqMTMRslwTO6VUm3plR4R3QVl2sFlXJ1+08jEi7dxDfFp9zWy0DVAt1L4YqtYNvTOpZGVhD13FkmO2iIDZvWGJK8dl2RcMpfu4zR+R/i2cylLUFWpLfwskvZWfNvf3dzLnYSbCxKhdM4PGFl4SF48Jmnygu1dhBtiw87LMtn0tHc7zRBY6bm08tPaPRMpl0mdjpmBSrvgNoucapXe8sQxZN/k7VaHiRP3q3rerLhAysUUSR4xJhn9/1F9/EEAL7TSvQDAQ+7FzHw3M9/BzHec4tIEMeIYZgtNJHkfbDt6SjqgNac4JhWR5Ou+nb2TVjLruJ1IqOH4SN5nljHaXamG6PbHa2u1bfUBu7y6f6SKLjFk75gUZiB5yTEgGnZjAMk3x7skL3uLDST4VEiP4x5zy9XuhJrDifKtTaIhBWWsI8iCmFJa7wfwRv39jQB+0zr+/dr75pUAvmptFr4oFim8CJEEK6bkPQPIJNwksUm77n+k4861PdIX7tOTQ3449d/W3mMfS3tsyN6x1wfhI/x9I1XeJn1kZGK+uyQg2eVjCIVmZm4UB/GcO6HfuS40kR9TXJz7uMcGoB/DJ2DaWxOduYQ4ubeX7b9+J5luiOhdAF4N4NlE9CCAnwLwcwDeQ0RvAvCXAL5XJ/8AgNcBeADAkwB+YGaZ58MUrSBVkzSmixDJu43SNUuEGpk9NLZka2KwE7VmGq7VUNi3oYidZ5OXxzRjhuguiTuNlAuA3MVSx4RQHVpS63TDO5t3K5ru6rYDZm4JuKBu3ZIW2blzIkQgEwnU1C1y6jgAMCubvOlc7I7D/R1DCqkvvGlMEGuPLhKQRPTM/AbPqdcIaRnAD08RagpcW/0sZpvU63wvXFyAI9vkOxU2YrpBUXTTGJK1SKAJVTA09o00zLaOs6Tl2+n3NTka3ZFowSXnsVhJMQTndfqTzs1vA/2e1WpnqyMvAEB/J+6k7SC0VaKpM0ZOW2ExMljfiRlcE1A42nxsZCAEPkudWGfmzvWHEMUybyW4ZXg8UWa3gfpI3kdmPtI3Wn5o1JFCgJ7J2h7Ju+lrhwzWhLQ2IjJxPzZfk3fvvF0uQ+Ez/wHd0ZwxkZn7aLJnvcE5AcrzKebVI6EZAbQyUK0nTi0iJ0CRPRTxK9OixxTkfdwBc1sHhrw5+EKYHB0wtAK2ORbR5scgQPLeUAR2RD+jadkan03Ijptl73xINNfbxnx3fLebBr40BnrgmDoxiuzHTLBJ5eIeHwurY2dNvih0B27IXt/PeLM0d42VmT0p39Qnhm3OoRpgYqtj0fkLJhoy323ij9RtlbbuPiuwDfv8AGxhAdZREn1SwQYCj/niuPTI0PZdlgjQhYf42K709kSsfd6bpWWmsjU8O9YMAC6KlghMVELXrtssqrKG327Z1NySvQ9zkLxNik0Z11oGtC6WzGgiGBYAahXQSj2e0yl6Fi2xG1NlIHr1LbRU31N2rYltBInpsmAA4AJEmpDtuRGt2XNMPo2ez7v5XXFngp207G1PYtUlZlBVt8Ruvjt1XSR4G9L81gFo9lsgeIOjJPq9wNXUgGFeGomINgJLjiGaeUer15NrZI0COvezOVCwzzYTfJLf+JQG6Zo8LH/3jj99QqfSc3e0N6ceacrZV0P2dfSd0ZyZbK3rtlMHWht9px8z80P+zo0LQfvv1AudpzHjoO6b63wePFaa4J69XPdJ/sC0+a0gE30ixNWvMY+LuSulREaOKaCjGdqamDlXQzX+RotvbfW9GPNAv/Nq7LPUT5NAlkSkF00ViPrfcffZmmiGOp69G8FQxTznpuy9mrb93XQcAbIfROiCthzcSMOCXf4pE4sdzyp1oEv2RNakvz2CNV885a9NP15zTzNa1H90x9LY7IHWVON63uiOObopu912XJI3v6XRzwFo+msgE70Db2TG+IXW94gZwOdx45htoo3BhuVVI2r20uSso9U39lc7baOtm2ejhuwBdFcypk7Api5j75nKzLP4yb4hldSO1iL8yRp6KCheIsZ4jqgO3OnYXc2+MJO2haUcCJmZzqGx87fhJTqE75I9EYipWwdiJB/S0iNpmjzWnuwPIBbuYp84WqIfW8iDzB/dC61K7vOSGVkpR1/X1+oBdG3zzFANVTfs0iF72/daIIZGkxP8qJMbYYp93GxUAS1HYKcqewOKjneR6GPeNwsNxr78qGMTuT6yd9dSGJlDfvOCeaej4btkb3nkdP7Xui7ZJO8j+NBkrP380nNnBHGURG+G4JN7VJcgJwm1B80j5itvGr69RZtN9kDXHa9nrweA/j16NlqVUfvf10CHEGQnbd0h+87krIEZNaS6kLppbUKcCZOCr/kmIlNNdrZfPNBq+I1wDvE3xG25ZFYqnTHRNBO2RQEYbd4uT8e7RiR5qTxCJkqTj3OtVK5b2GFqK1r90RH9Ui+3u9+qpR1tdFVcqOEr+bvD844LHdBOxhnfa5vwbc8LdTMQio4Zp2Oj1WmMXK2QETL1aeDublU22WszBjOL7ozuaK2RxzUnTVo1Ld9rNEJ1WurcO2as1uvKoE/6lqbf5CHZ9AGYhViw6oitENiLsCxzTec57ElW3/PFgvyFtPglJ2x9eQfqi+Gk7Ec/EySS9/aoNkk7jaVnvvH5o/sgaobU8WsehFSbNiDb6u1JNK3Vq8iCpuFZk8tFe4ztZzGujW6ogya2jcfGbYbuVdVqdLY2RwLJeN5LUxaAJhuB7LVMHbI32QprI8h2Y03h9th7mKMxD60jjq88YD1XQ8Da15KoG0pW1wUXTd0A2voB9OuICaAmTd7bnbt575KrZCQOU9/zrPZ8t64ZtThtQgexYaUPODKi98HbowbI3puXPQxO9ddPrUCOnXv0UN8he5NXZ39NOx6OPWGnh+eNicYM3c2w3dBEoaMjGo2/LFtNX924/W9IV1oAIxJEYqNpPHdsTbwtQ7v8xAVwQGe9QWiP3Da9rQD0TSitGCMJf8qINNbJqxO2kF7N2IwAOtq/HS8JgB1qoeehA1v7FmzvTaKRJO+ahFKxtLa/UbK/LojeIGovk8g7xU6fSvqpmCPeuk+mulakbBGASPiANXx3SB8AKjTanDLdWLLb9wLAzVJ4YcjuLtaKlHVD3q5Zpi7QWSFkYp27+fnydxaYSUTdI5QR73zxTVJ83lduuAyVQBKwTS8FxwPQW33rmHN68gDtuw+RvM9M48ofKr8QkV/HPvhHQ/SpQ7XUyZGOyxrQsUMO9sxZwqc+Bb5Gb5Nqx3ShtbjmUNWSmavpqxtYmn7davgWosN215PENufYcwgpKEgxjbSIyo57LnRGzUhA0vod8o9vBuPc173XGAyxDftGdD45OlEwhbphET4Aa4U10AmiZn5LcodIXjK5ptjiO+ki7f86JnlA9qTtgIjeTkSPEtH91rF/SkSfJKKPEdH7iOhmffxFRPQUEX1Uf35pSeHHggdoFUG47l9zuhOmgutwJZaGwfbw154wtYbCTVz72vqYe1WV+t0saVe/uao713LlaPJuPr7G7ilHQ1b9vUYDWrq756oUv8jeS9X9CPkQkffTy9e9lyv/VPjef829dx/czMbd38CtFy7h2pq6PfFuv1tfnBp7olXQ4r0kL9TVJGyA5Nf2vElhnHcAeK1z7F4A38zM3wLgzwD8uHXuM8x8u/68eR4xB0Iikl6SAWQvVPhNhETtdDIjyb490do9nefskb65n70zltsJdAjduc73DEPt024YimbiWCB/baMPErRN6BL5u2lEmZxz9rXmPNDvGEJIIaoBZCbuTGYjFEXVzLcAfbI36d2PXR+avAJavCSD5D6Zqs1nxImemT8E4EvOsd9m5p3++WGo7QK3AYlIPI0gSPYG4jLr8ATS7EjNO9S5ib7JjhYHBDW54M5VHVdKi+Alknc1uRk1LnFls0SoBXU+UfI3+Uhau0T+bloPqc+u3btIqDsi6UeI1kv2rlku9u6t+3vv3XsmT33ZgOYuYW1tHpjHRv+DAN5t/X4xEf0xgK8B+G+Z+f+Z4R5pSJ2IsUwnHZu9s2rQG+jLXWJuT06Vln05QZauX3nfhDLpWV0ZtO02aLeVJuoEOz7gTN52PDGs+9nySN4XPR9w65hTjoPmRsyEtkXYZPv+u2VT9rOgTp1x7POpYX5teCKLBidoh5KX9O5TFAWfl1ZzvujXT3PcbAJu5nTsaZrQBGuTRhhd+s65+QgjxSQFbm3s2TtnEtET0U8C2AH4NX3oYQDfwMyPEdG3AfgNInoZM39NuPYuAHcBwGVcnSKGwpAX6hKIO0ErBfpy47/4yN6eTAxhH8NNqcNJnahzJ+gcbwwvfM+VMlmWWPkHD9mNvBLJB72wzPuuGy+f1usnTdYOifdW787gXeXDUFc/Z1JcXEsCtITv884RHifoB99NGE0zKP5TRoPR3QoRvRHA3wfwn7MufWa+xsyP6e8fAfAZAH9dup6Z72bmO5j5jlNcGivGeLhBkkTThlBB7ckqN21oWbftfdIcsjSkFW3+g7UsMZP04XTy/MZIrUc0u7h5FtQleWki1qQxGz87Zh7fvV3zTy/9nLb5ua8XJnC758OTta79n900kkkoYi6UTUuy1n4Q2vwKGKXRE9FrAfwYgP+YmZ+0jj8HwJeYuSKilwC4DcBnZ5F0CYQ0e0erBywCEVaaNn7GYvxv636AMgv5TAArTfYOdhm14XOB9JlsJKRshpEin2cVsffa3qRtx/ak8zQ/i552H5UFaOTpRNps0rT+/ou8c4/JMgjnffpWiuuTOm/q1+WeLL7RnqN0edM5x0PK2tZJfs/yRYmeiN4F4NUAnk1EDwL4KSgvm0sA7tUV4MPaw+ZVAH6GiHZQlro3M/OXxIyXhl1ZQg0yZsYRTB0qS8ucY8IKwLLr+jZ1SCD5tRBs0CnpE80Fs05ABu7RI4zQbmCiOafU5GIRvk32qXA3UDH33vcoLkQuARMf4Kn7QHjxlYtUn3hz/2BijxafISJK9Mz8BuHwr3jS3gPgnqlCTYZb6WybopjeQ/b2oh0bekKzswCpIX2j0cseEKIvu/0bidp8yiKspSZ8Qh3ABjWpaMdizDJCerbJnagleyCdOMeUSUBblbw4JgfOCk3iOnl6V9ym3ipUvyNaey8vieSDjgpC+oUVjxzUbJ+wh5ji+QjZ27C8V0gw4wCBSSmfjX8MfGQ/J8FLk9CDru/afA2StHrB62YIuguYqPu/cb0s5PRa41bmFrRkb/KoOb2c3S0QBz1Fn8xCGmxsn9yEm5kL22N2nr7RrS+71Hc2kOBVkhlI3j6+B8Jfi+yPj+ijk4aBl+pU8g7Zu3Bie5BD4Czm7/cqSLZLuhhK6pGKFvXEsTyOAAQ7Njs/6XgnOJw7eirQei/5zGC+ye/kHaxaUw65i6IMTLwcYjBTO6FuNmiJwSXJmkVvm66b7XxmiaHX91yNuyfFchWjfo6RO8VBIvHa7rnEfMYoMgOxFtnv15lzS5iqUTsTjcHwAgGvgs61S2NABQv78Pc7LMnborcIRlh1q87p/73Fbtbx0IraGNznljR9l+QbzxuhiVDRvSbl3iNGWWvYnoP3jIVbsD9pN+t+UuWQ8vGe29A8SJNk/+/1+DT6IfD14LbHTagHtrVQ224v+aID6xH8SAzytggtEJJg+V97NXt7QxRAbkS+MuyRu7bDh0w2dugEdwVsXYMAYZvCyMhtX5jRhBfVOt17SfeZMFdzsCS/YVzfRB+Ch+y9Eysu2QNpiz42jqgnjmPKCWSk/gvEOIjsY5DmLVwikkw2dlwbfU49r77GmFuYuzZ6kWAneNTMMHEbPJ64XWJs8jfp/gMxWNPd4MQ/gN7ckpxkvxyQiT6RRLwvRnipIZ/0QyJ5g+A6ApVgSGbt99gqW2AY2YcmSY02b3nYiCRva/2A9rJpf/bi4Zt7zUw6ixGBOCryE75PliF25tHPEuqwY+V9gO1sSRwX0e/x5YrDW8fn3iX71Unet7ApMY13WTwQCYsQSOcz4cgCCAucHO3Zd61F8mSbZySSd+9hyN424fh89BvSnKDVD8Vc+x0MCUOxtEYa6pAOAUNDUCyM4yL6NRahAN6XOpnYBf9977kheUodlO+34EMNCC51qf7UPg+eHtlbZdoJdOYh+1ZA+ZxN8q5Nnggo2+9s+9RX5rm6923cLo18zQmBdFO9gGyxC7p+FwIdEqGHsCGyPy6i3zNiWn0QQxqxlN8I8hh1b0/apI20Q6gqRbpOJMcmnATQNSmklCsVgJTEZ4u3PG74pOxq81ppYGiyLwu10Yplq++YcQzciVrJ9dNsxm2db/Iaq53HCCU1z2Mh2YwOMtGHMKRHHpJ2y5paxF7bYMozdIix7mn3bUTQISYcj10egleNuzDK/dgTseaYNFKQRmyhDtgmcduX3hPFclatfq3tLDM2gW2MK9bEEgskfL7EQ3yM3eskzLnwwvVldn2c5ySJ0NoDIZ27ZkFM6yLkO2/O2+Ru0ri7Vrlw8omHV+ifnxrrhwrqfPYOaY3I3CbTKfmuPRe2QWSijyEyKRTdknDoIhIflvTCGDKsT00vdRT2dT6y19+9i6l8ZO+RqRfWwJ10NTZ5Kd0UuCOM0CRx4FqXyCVi3xvZx4jX1wEMJexjIeqN2OeBbLoZBg+Z7G1Zc6r9PxVTtPSx1wp2916AOPJ7LiUhps1LkFwrvfl3TS2LhRh2sFpQrLmezc7HV87SvYaso9hKJ7EhkgcSNHoiejsRPUpE91vHfpqIvkBEH9Wf11nnfpyIHiCiTxHR31tK8IDA8+c5ZAn+GO14btPIFu6XIo+LJUw4Bh73z542D/RMOk2a1Fj5qYTsyOTdzGTFqIeLEecS5p6pmIs7NkbyQJrp5h0AXisc/wVmvl1/PgAARPRSAK8H8DJ9zf9MRMJunCvDtc3OjehijomdxFCsROpcc+cjwmfCicXDSTBl9YhTMNs08PnQ++qIHS7Bez8hJs7YXbOmkv3aHbsPnNhpL90p7Jnk9915R6Vi5g8BSN085E4Av663FPxzAA8AeMUE+cYh5lWxJkINLlZJ1tTsAnAJ3UfsveOhwHDMTQC0JkCameswI5Lmt/l4whGIgcks27xtrycCl/q/7aVj8imLluSLAijLTppm28DCdCoW2VuhkntzB+6+ttcT5tTuh7bvueZjzCcp+f7f8ZQxxluI6GPatPMsfez5AD5vpXlQH9s/tkDqEjY4rJuCMe5/Sfvzzg1Xm/ehcP9bE7ZSPoakC6sDIIvIbbI3vxuRPJ0QMH89ObJ6NwlbUfr2iLFv/20AvhHA7QAeBvDz+rhUcmILJqK7iOg+IrrvAtdGirEnDOitJ90jhClawIKyz21SYGkoP4MZZxRMsYVMPfZ5oEPcXa3djoxZyO8zFvcngCRXy+uZ7MeSu62tSzzgKdNV3V8FjHrzzPwIM1fMXAP4ZbTmmQcBvNBK+gIAD3nyuJuZ72DmO05xaYwYhwu7ckztRFIr0pE08mAMe/ecPxO/qcC1/vgmaqXf7sIsg8JJbx1vtHop/Yh3FiWXofXt0LXesZp7qJwippqQS+xaxD+q9RPRrdbP7wZgPHLeD+D1RHSJiF4M4DYAfzBNxJXhkrL0XUJs8msfowTfPWe+96KVV/KzN7DJXiB+NoTe2Py7BE8d+75A/jXSbccu2TeHhYlY15zjS29f4x6LvL8kwj9WeN7FXm7tKfO1NfuoHz0RvQvAqwE8m4geBPBTAF5NRLdDmWU+B+CHAICZP05E7wHwbwHsAPwwM1fLiO4KusAS70NpDM2S/YEmjIVC7E5FsxdvLNIl0F1bULPe4q8Gass8YsieSEehbLOkGu1mIgXUfVlNxpLdOUydLAyERiAz8duJ8mmlD2mWQPD9ufsojALRNlwhB+1LsD1T56Y3B2fmNwiHfyWQ/mcB/OwUoTaNIZVgruh1yX7ZfjIJYgbCnyUui7sgzI2DYx3rRNG0o12atJrsudBpbLKWyJ70QeMkY9Lq63rav/usdvohmBKcziBBybmuo2HuCWtr7SEc18rYKVr9BEKObru2z5HB0MrmhtgdCqu83XJIJpZQGUnbMlqab3dz8gpgaic7Wf1mJVzrKWDbxbUXDTEDVHddLplV5EqX4EO+39air+6eueuTbI/sc6CzPg5lFD8Qx0X0IRzqC1xaS5ga4z5AFqPMBlJYBKC7G5Wr4cMifFimG8DS3GtwBUXq1nVqxNBO2DWmHEejR4oZJ0byGyDVg9bsNzwxvGVtHjhGoneJ51AJHtj/4hnpfimksJBmmLw5uX3OyFsY10ub8Ftzjokn31xX1Y3LJLFzT1uLD00O2+dDiJTpqNg5U+LYS+2lt43fRuz0GaNwfEQPHDa5G0RIfso2hebapGtiu1GNRC8QnG2+CW3JKG1ODuiJ1rrduKTZa1bnqydbDdkDSnNvtHt7orax8wtafALBB002Q8hyqP3erfeBkZao1R9Du8kQcTREv9aQdPZFKglavBT8KkTe3mBZYzTHFeDdnBwQzTlNepPMaPcoNdG22n6j3Zu8GjOOQ+zGRTNRVnWNbctP1LZD3jdDkarlZ4I/ehwN0S+F0ATjrH7KiWaaWNhem7xTQvxuiuw9Wn1zWnoudw9a63eH8G3CtOz2qKD90rvXdvLX+Qwqp4lKR+e9jDWpAfOZdJbEgZuFtm6fBzLRBzFqk4chBD8Tuc+RPonEfOQykhBMpxk04QDphO9uOA60fvc1ZLu9dsVkpq7dvr1ZfzWuge/9jSX5ogCqxGUnQ9ZOCKS9uUnZGNlLC8k2MLl9KDgqop+j8g7unQN7lQYv25gHQZDsQ2Ua2IwlFT3Cd/et9RCsLS855N7A3nTcNeXUBQA9ctAEy4l2bgDtaCAGXx6GrApS3j6mk2pcRj1la7+n1M5mi4vjpPASKQpHExF0w2S/MdmOiuinQiT5VA3dt/Q5RugTAlkB8E8OzoWFSd69zqvduzIJWn7Hhu/a7lMmas1Cq27GfoHd9HM1bkN4vk3DrTrl7ZzHrpbu3GhBsvK1C4nsQ21oY4QKYJMd0dER/VitfjTJuwGMfJXSG452gGYvNWrPQqK1EC37iOvrILIHOuUfJXv3etErx3MfF4VFSCbv6IYzCW6VvfsIYSCca1TWATm3tkhqg+EJZkOqfHt+juMheqsC22Q/eqLEfRG2hhQjd89GFyJSNHrTuN083MY9N+mP0OaDSLwmmewB8X205/rxcsQ4OTbZp8hspy0cDXRQxy3kbbR4nxkjoOUPJfvBStGBT5ougaQ5u7U7VhwT0TuYneCF3919Qp3rIuTf7xz8Q22WOgNDBkBc05cQ6wjmNtlI1ywQHsLrd+/4uYtkD8i2bPu53LTuyCJGhAiRzlAAABM8SURBVENWyYbIHvBq90oMYV5j5pXPo7Cxuam9YANkf7REPwoBkk8yyXiI30vq0n3NDrt2DJmOE4ghFquxhwjfB49mGMXcFTaV7Ado9V73UkvD7wVFMyg8BC8dKwTCb84FXCJjZWi/G/sZpBGc5x1GTTpjtfp94FBHDhs12wBpYYrfDuDvA3iUmb9ZH3s3gG/SSW4G8BVmvp2IXgTgEwA+pc99mJnfPLfQi8BD8mMJ3kvusRFDg1JYzs/hBjyG8IdgA0NQL0ITtLYJx/HM6XvueFa4OuhN6gLdd+tq+kPJVCJx6f16tHs5z5Fa/Vy4HrV5g5XnFlI0+ncA+B8B/Ko5wMz/mflORD8P4KtW+s8w8+1zCbgXxEg+NpEqae8usft2GZLON3HIdeNl3UBLtPMQUMd6Zh1bw7cxwN6bbKseAm8MlQENQCJUG66JBZbm7trrXX91aSJUZdBJ0xwGtN+7bSqqnPfsaPqhMtQk3OnIffXO8fOHkUVI01MMBLKXzJyb0fJTOoeFTSN2+Uye+1sJKfHoP6Q19R5I1aJ/COBvzSvWikh9gYEwBF6SDxB8t4EbLdCQY9U2UKdS9ybhfOS9tLaPRI+nfWk2jkbdbGYCyASaUi6ul01z2LMRytA5CIuEpZFkx2znmnZ8E/MW4YfIPgi7zh2qWSUFCe/KS/Ab9waaKt13AHiEmT9tHXsxEf0xEf0eEX3HxPzXR2xSc4wfvIfkzfd+h5EwSlgSA7SlzWk6op29Hv8B0IYtbo+xbwUt1+3HlinktpmyJiM2+Z+CfZLTgZptFqvPe24nUydj3wDgXdbvhwF8AzM/RkTfBuA3iOhlzPw190IiugvAXQBwGVcnirEipC3vkq8NuAb60k/BnjSxWbavmxNWjPux6AVUc11ZLZt/x34vyZICj22/q5k7o7cZte3VJ2n3PXIQOr1kko+tjt9AOxjdpRPRCYB/AODd5hgzX2Pmx/T3jwD4DIC/Ll3PzHcz8x3MfMcpLo0Vw4vZKumAuOM9IjFaXC9UbTdP97qeZpiar09e32YZ9k5NvnguE7cXHKMRDb7G1polDRqY3Ng6GjuAJtiZEL7YW5ax3xKMhp/iAaZOBk7ZI4LD1LAXwdwjG8klu6D+9z1iyhP+bQCfZOYHzQEieg4Rlfr7SwDcBuCz00QcD645jfB9PtOpcMnVG/xLmJirYyRfB3/3yMe+l4/gDx0hQpfSGRiTyZiPyVIqz1CseiGPIEKkIxHEEqbF6wVUeMt7tMkmdN2KnWu0FhDRuwD8vwC+iYgeJKI36VOvR9dsAwCvAvAxIvoTAO8F8GZm/tKcAqfAJXdD+MnEn3wjD8kCAaK2yNc6J9p4WWuNvrw69xuoeUsaqIuZPBmGaPaL2ERjHYKdxpfOIuvmXUneL9pu7yvT/shASGcIKED6s9vrrzeEynZIHbTz2fAoKcXr5g2e4/+FcOweAPdMF2sEdANNIfKk8LgdG5un8dsrLq3AWQZytMTmhmg2sAaUC2VzyiF8yxUwqMHbSCT+yRtlDEBs8/ApJB9772T7u0eupyLw7NY75ALdCJOO3d67ohlo97h17fmup47rlrq2L/xYSPGG5sRMm6z06uDAeFdDotLu8y1e1ytjezFV3PPucnoXniiJ4sQc0F11CXSJ33z1kO3cBN/LcwVM1d6HhkKW/KFT8g3F3emusLUmal2N34WuJ/06Eu6QBpO8b+QWycdbPodsChxqi4+lH0nwa+C6JvoeBK3eJftgDHSb7PUx71J7wFlu72gkrl3YJY0JBO8+h3u/rWNKGOQp1/Xi5TcbmFCf8N3RHuB9Z17t3oVvriDU8YvpHVNgDFteEZ2KoT7yvvTCu4kGNZTa5p7nTo6K6Mc05JRIiSF7KyAQvjrY1aakoGYdebsrNcWGHPGcSZH5EDBpHiW0yceQ9MJ1IuE7gc06K3GBLuEDfcXAOtYQfmh+ecTILqbJJ5f31uuUz3wzleRTR54+8rYXr600OX5URO/F2BjoiX7uYhx0V5sLxFjxwkfwAe39kAneYBEfbrcDH6PN6us7hO+JZNmJs2NnF+oIHMIXMcBslzL/Mmj/gKkYYqefqx5PNdcE2n9wQlzCih5Qx0v0vgrqiZeSRPaB1YxBW62B0PDbPITQBSG3PQeTCP6AzDZepBDSVNJy7fN2nfGY/bxZuYQPpAUoG0LuRhZbfjvtEJI/FAViRNwb71xRygplIOz15Cu3Pdv0j5PoUxt9jOwNYg1C0uSAbiN0Sb+XR7r2vrjWfgw22aXgKAo9sjfnnFg7AIQ5moht34cYubv3Et4n+84vvbfs0t43wCAtPoXkgxOttqlWvIFnfmbPOBqi56ETTG7a0LA8FXpyjsF9bcBykUydoR+1WXcKxobO3RMGm23mIKVQQxSjgda9OgMI9aYOmIuszcXZONsNIQSvZ0yE2APp5GMr1pMFOwavK6UUojxlK9CAO+3aaxuOhugnIzQs7yV1GraUh6C9NcnmaMxTEMpzZW1+cyRvzkfIvj0kmAB7l3lGAYA8EjAY8d78bpIbHrXtoWNJJvmxBG+fy143G4NA9kBbKaRGE9TmpI0opsqXiqGTUIdG8PvGFLK3jrvfo4QflCn8zmYh+SVIdx/mmwBi6zdEko9sQOSO0oOhw1eYlM1E70KYrE0loag2N2aTjbHYssamsXlydzGQ7IGwkiClk/Lq3Ssm5oZHbJuEpc33SF5637H9n61jva0/V8JxEb3X02ag/dXklep77ekUeprDhEaWSor7Wm065D6LEfqWSMtTX0YpCSMnR/fqKnmgSApx4JK8h6R7+0bYMB24uzHQSjguop8bqb7XAZdNG/sgx9B1wXAPA++3uja+RdKKaeN2OiDN5JP4nNcNyaeWsYAgyffOySTv3QvahbNbmEv2+w6ZkIk+BlOxRrpsdk+vS46+/S7XlmsU5twndJ+bXHR808eTVpvFdFv+3jGF5EaUl6jgCCRPRF1i99jf3es6+dllvaEAdNFSI6IXEtHvENEniOjjRPSP9PFbiOheIvq0/v8sfZyI6BeJ6AEi+hgRvXzph4iCqFu5zO9YhbNDxW58T8gYTKhgqdKHzoXSpnwWhR3ONxLWN5rOVyfs41O1sAR3xtToq7OH3PZhTs0ztQztdNI+yym3CtVBH8nb959K8k5Yaxf7NueklNwOwI8y898A8EoAP0xELwXwVgAfZObbAHxQ/waA74TacOQ2qK0C3za71D7EKsLUxnpgZD+GcOcm7qEdw+QOQiJ/kdgDHcNcxD4SQyJr7gWT2syEsoxcE1JaAhe138VOIEFOybwWCki4AUSZi5kfZuY/0t8fB/AJAM8HcCeAd+pk7wTwXfr7nQB+lRU+DOBmIrp1dsmXREw7zFgcexsxzP2eY/M4iefczXJGa/BrmW0W7ijNu0+uD26blla+GrONq80X1N0KcCzsDeb3jEG1nIheBOBbAfw+gOcx88OA6gwAPFcnez6Az1uXPaiPuXndRUT3EdF9F7g2XPKlcEQEf5C294EYY3YSTswrlL1bVcruVuaaNe67BJYgeOsdDd4BKhCozLcwSvSoSbmvZa5pd4xzCH4Fsk+ejCWiG6F2j/oRZv5aYNZYOtFjHGa+G8DdAPAMumUbjLQ1kh8QQtefhTwBe4wIRb20n3+R6JhzILbuYmuTqhL2YO6KbRjUyhJuHz0O603GDnwWqU75SH3PZJ9E9ER0CkXyv8bM/0IffoSIbmXmh7Vp5lF9/EEAL7QufwGAh+YSOC7sSG+MuUg+1FjnbqgDvDauF8KXSHxzz+yGsPamOwBi3xeGeihFNg4JxbFR3jdmMnh4Z+vfgznxvS+AFK8bAvArAD7BzP/cOvV+AG/U398I4Det49+vvW9eCeCrxsSzJEY35qXt8UsPozMZ9JBitxV9qvc9N7ORibokpHrLLHb/AaYbcREU+UnezCcURUvypi6Y62zi9030S/lvBCka/bcD+D4Af0pEH9XHfgLAzwF4DxG9CcBfAvhefe4DAF4H4AEATwL4gVklDqDR5rZmgslYH4JmZhNGZxQwR/1J6YA3SAhB7MNjLbJD1Jjt/rzx4103yoKAsmzP2YHOalZqsegiq/Ovudke1OwS1mwiU9fd8ttaUDNm/jeQ7e4A8BohPQP44YlyDYc22Sxuf51zoc6eMdltcQiWLKM5iNjxfU4pm0H1KhS64NAIfiimvB+33CSSTyD44OYg1gRsZ9KVipbgXe28NKtbdUfQqQu1Gp0V1O79rDuHZlVsjnUzP5aw025y8g5IblSDn38qmW5xVGWXgXmfA2LJjAohsfRGHkthqNwD33d0dbaTn0jykh99SGt2PGx6tviiJXmyzDkAgLpWx4y5rbTCGtQFAF1OBfxk75NzDzgaoueL8/D5A2tnyeAqngZH/PwZyyCxXo1NP7Q+pqbfqDq2OjaodmVkZGRkzIlM9BkZGRlHjkz0GRkZGUeOTPQZGRkZR45M9BkZGRlHjkz0GRkZGUeOTPQZGRkZR45M9BkZGRlHjkz0GRkZGUeOTPQZGRkZR44pm4P/UyL6pN4A/H1EdLM+/iIieoqIPqo/v7T0Q2RkZGRk+DFlc/B7AXwzM38LgD8D8OPWNZ9h5tv1582zS52RkZGRkYzRm4Mz828z804n+zDUTlIZGRkZGRvDlM3BbfwggP/L+v1iIvpjIvo9IvqOSRJmZGRkZEwCefc3dBOqzcF/D8DPWvvGgoh+EsAdAP4BMzMRXQJwIzM/RkTfBuA3ALyMmb/m5HcXgLv0z28C8BiAv5r6QHvCs3E4sgJZ3iVxSLIChyXvIckKrCPvv8vMz4klSiJ6vTn4bwH4l/a+sUT0RgBvBvAaZn7Sc+3vAvhvmPm+yD3uY+Y7osJsAIckK5DlXRKHJCtwWPIekqzAtuUdvTk4Eb0WwI8B+E9tkiei5xBRqb+/BMBtAD47t+AZGRkZGWmYsjn4LwK4BOBevS3Wh7WHzasA/AwR7QBUAN7MzF+aXfKMjIyMjCRM2Rz8A5709wC4Z4Qsd4+4Zi0ckqxAlndJHJKswGHJe0iyAhuWN3kyNiMjIyPjMJFDIGRkZGQcOVYneiJ6LRF9iogeIKK3ri2PBCL6HBH9qQ7pcJ8+dgsR3UtEn9b/n7WifG8nokeJ6H7rmCgfKfyiLu+PEdHLNyDrTxPRF6ywGa+zzv24lvVTRPT39iyrL/zHVsvWJ+9Wy/cyEf0BEf2Jlve/08dfTES/r8v33UR0po9f0r8f0OdftAFZ30FEf26V7e36+Kp1oQdmXu0DoATwGQAvAXAG4E8AvHRNmTxyfg7As51j/wTAW/X3twL4H1aU71UAXg7g/ph8AF4HtbiNoEJa/P4GZP1pKBdcN+1LdZ24BODFuq6Ue5T1VgAv199vggr18dINl61P3q2WL0GtuQGAU6iFmK8E8B4Ar9fHfwnAf6W//9cAfkl/fz2Ad29A1ncA+B4h/ap1wf2srdG/AsADzPxZZj4H8OsA7lxZplTcCeCd+vs7AXzXWoIw84cAuJ5NPvnuBPCrrPBhADcT0a37kdQrqw93Avh1Zr7GzH8O4AGoOrMXsCf8B7Zbtj55fVi7fJmZn9A/T/WHAfwtAO/Vx93yNeX+XgCv0e7fa8rqw6p1wcXaRP98AJ+3fj+IcMVcCwzgt4noI6RW9ALA85j5YUA1MADPXU06GT75tlrmb9FD3LdbZrDNyErd8B+bL1vqhyvZZPkSUandth+FCpT4GQBf4TaOli1TI68+/1UAf20tWZnZlO3P6rL9BVKRATqyaqzaztYmeqk33qIb0Lcz88sBfCdU9M5XrS3QBGyxzN8G4BsB3A7gYQA/r49vQlZS4T/uAfAj7ITycJMKx7Yg72bLl5krZr4dKijiKwD8jYBMq8rrykpE3wwVtfffA/AfArgFahEpsIGytbE20T8I4IXW7xcAeGglWbxg5of0/0cBvA+qQj5ihmL6/6PrSSjCJ9/mypyZH9GNqAbwy2jNB6vLSir8xz0Afo3bGE+bLVtJ3i2XrwEzfwXA70LZs28mIrPGx5apkVeffybSzYCzwZL1tdpcxsx8DcD/ig2WLbA+0f8hgNv0LPsZ1ATL+1eWqQMiuoGIbjLfAfxdAPdDyflGneyNAH5zHQm98Mn3fgDfr70CXgngq8YMsRYc2+V3Q5UvoGR9vfa2eDFUOI0/2KNcYvgPbLRsffJuuHyfQ+2GRVcA/G2oeYXfAfA9OplbvqbcvwfAv2Y987mSrJ+0OnyCmkuwy3Y77WzNmWBuZ6f/DMo295NryyPI9xIoz4Q/AfBxIyOUbfCDAD6t/9+yoozvghqSX0BpEm/yyQc1pPyfdHn/KYA7NiDr/6Zl+RhUA7nVSv+TWtZPAfjOPcv6H0ENtz8G4KP687oNl61P3q2W77cA+GMt1/0A/rE+/hKoDucBAP8ngEv6+GX9+wF9/iUbkPVf67K9H8D/jtYzZ9W64H7yytiMjIyMI8fappuMjIyMjIWRiT4jIyPjyJGJPiMjI+PIkYk+IyMj48iRiT4jIyPjyJGJPiMjI+PIkYk+IyMj48iRiT4jIyPjyPH/A7HWqEI81JY/AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1ca91cf240>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(scores[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "jupytext": {
   "formats": "ipynb,py"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
